/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#pragma once

#include "节点/节点.h"

#include "节点/插座/C_物体插座.h"
#include "节点/插座/list/list矢量插座.h"


//	0				1				2			3				4
//{ {L"+", ""}, { L"-", "" }, { L"*", "" }, { L"/", "" }, { L"%", "" },
//	5				6				7				8				9				10
//{ L"+=", "" }, { L"-=", "" }, { L"*=", "" }, { L"/=", "" }, { L"%=", "" }, { L"点积", "" },
//	11					12				13					14					15
//{ L"差集", "" }, { L"相交", "" }, { L"反射", "" }, { L"折射", "" }, { L"射线相交网格", "" } },


class C_矢量计算节点 : public C_节点基类 {
	

public:
	C_矢量计算节点(S_设备环境& ctx);
	~C_矢量计算节点();

	S_Props		m_计算方式;
	S_Props		m_是否改变原数据;
	S_Props		m_执行代码;

	bool	f_update();

	void	f_计算Vec3(uint8 方式, std::vector<vec3>& data);
	void	f_计算Vec4(uint8 方式, const std::vector<vec4>& data);
	void	f_计算网格(uint8 方式, const std::vector<S_Mesh*>& data);
	void	f_树空间查数据(uint8 方式, const std::vector<S_八叉树子空间*>& treePath);
	void	f_物体(uint8 方式, std::vector<S_物体*>& objs);
	void	f_线段(std::vector<S_线段>& lines);
	//void	f_与矩阵计算();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void        f_getStr(std::vector<std::vector<std::wstring>>& 文本);

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
	void	f_Copy(const C_节点基类* node);
};

C_节点基类* f_node_创建矢量计算节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载矢量计算节点(S_设备环境& ctx, FILE* f);
void		f_node_保存矢量计算节点(C_节点基类* n, FILE* f);



class C_矢量逻辑计算节点 : public C_节点基类 {

public:
	C_矢量逻辑计算节点(S_设备环境& ctx);
	~C_矢量逻辑计算节点();

	S_Props		m_计算方式;
	S_Props		m_是否改变原数据;

	//bool	f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建矢量逻辑计算节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载矢量逻辑计算节点(S_设备环境& ctx, FILE* f);
void		f_node_保存矢量逻辑计算节点(C_节点基类* n, FILE* f);





class C_两向量转四元数节点 : public C_节点基类 {
public:
	C_两向量转四元数节点(S_设备环境& ctx);
	~C_两向量转四元数节点();
	S_Props		m_计算方式;
	bool		f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建向量转四元数节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载向量转四元数节点(S_设备环境& ctx, FILE* f);
void		f_node_保存向量转四元数节点(C_节点基类* n, FILE* f);



class C_合并XYZ节点 : public C_节点基类 {

public:
	C_合并XYZ节点(S_设备环境& ctx);
	~C_合并XYZ节点();

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
};

C_节点基类* f_node_创建合并XYZ节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载合并XYZ节点(S_设备环境& ctx, FILE* f);
void		f_node_保存合并XYZ节点(C_节点基类* n, FILE* f);




class C_分离XYZ节点 : public C_节点基类 {

public:
	C_分离XYZ节点(S_设备环境& ctx);
	~C_分离XYZ节点();

	bool	f_update();
	std::string DEF_节点编译函数;
	void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
};

C_节点基类* f_node_创建分离XYZ节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载分离XYZ节点(S_设备环境& ctx, FILE* f);
void		f_node_保存分离XYZ节点(C_节点基类* n, FILE* f);




class C_混合节点 : public C_节点基类 {

public:
	C_混合节点(S_设备环境& ctx);
	~C_混合节点();

	bool	f_切换插座();
	bool	f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
	//void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
};

C_节点基类* f_node_创建混合节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载混合节点(S_设备环境& ctx, FILE* f);
void		f_node_保存混合节点(C_节点基类* n, FILE* f);



class C_设置矢量分量节点 : public C_节点基类 {

public:
	C_设置矢量分量节点(S_设备环境& ctx);
	~C_设置矢量分量节点();

	S_Props		m_是否改变原数据;

	bool	f_update();
	std::string DEF_节点编译函数;
	//void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建矢量分量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载矢量分量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存矢量分量节点(C_节点基类* n, FILE* f);



class C_四元数计算节点 : public C_节点基类 {

public:
	C_四元数计算节点(S_设备环境& ctx);
	~C_四元数计算节点();

	S_Props		m_计算方式;
	S_Props		m_是否改变原数据;
	S_Props		m_执行代码;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建四元数计算节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载四元数计算节点(S_设备环境& ctx, FILE* f);
void		f_node_保存四元数计算节点(C_节点基类* n, FILE* f);




class C_四元数变换节点 : public C_节点基类 {

public:
	C_四元数变换节点(S_设备环境& ctx);
	~C_四元数变换节点();

	S_Props		m_计算方式;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建四元数变换节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载四元数变换节点(S_设备环境& ctx, FILE* f);
void		f_node_保存四元数变换节点(C_节点基类* n, FILE* f);




class C_向量角度组成四元数节点 : public C_节点基类 {

public:
	C_向量角度组成四元数节点(S_设备环境& ctx);
	~C_向量角度组成四元数节点();

	bool	f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建向量角度组成四元数节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载向量角度组成四元数节点(S_设备环境& ctx, FILE* f);
void		f_node_保存向量角度组成四元数节点(C_节点基类* n, FILE* f);





class C_四元数转换为欧拉角节点 : public C_节点基类 {
	
public:
	C_四元数转换为欧拉角节点(S_设备环境& ctx);
	~C_四元数转换为欧拉角节点();
	S_Props m_转换类型;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
	bool	f_update();
	std::string DEF_节点编译函数;
};

C_节点基类* f_node_创建四元数转换为欧拉角节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载四元数转换为欧拉角节点(S_设备环境& ctx, FILE* f);
void		f_node_保存四元数转换为欧拉角节点(C_节点基类* n, FILE* f);



class C_四元数转换为矩阵节点 : public C_节点基类 {

public:
	C_四元数转换为矩阵节点(S_设备环境& ctx);
	~C_四元数转换为矩阵节点();

	bool	f_update();
	std::string DEF_节点编译函数;
};

C_节点基类* f_node_创建四元数转换为矩阵节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载四元数转换为矩阵节点(S_设备环境& ctx, FILE* f);
void		f_node_保存四元数转换为矩阵节点(C_节点基类* n, FILE* f);



class C_几何计算节点 : public C_节点基类 {

public:
	C_几何计算节点(S_设备环境& ctx);
	~C_几何计算节点();

	S_Props		m_计算类型;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建几何计算节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载几何计算节点(S_设备环境& ctx, FILE* f);
void		f_node_保存几何计算节点(C_节点基类* n, FILE* f);





class C_三角函数计算节点 : public C_节点基类 {

public:
	C_三角函数计算节点(S_设备环境& ctx);
	~C_三角函数计算节点();

	S_Props		m_计算类型;

	bool		f_update();
	std::string DEF_节点编译函数;
	void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建三角函数计算节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载三角函数计算节点(S_设备环境& ctx, FILE* f);
void		f_node_保存三角函数计算节点(C_节点基类* n, FILE* f);




class C_向量归一化节点 : public C_节点基类 {
public:
	C_向量归一化节点(S_设备环境& ctx);
	~C_向量归一化节点();
	S_Props		m_计算类型;
	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建向量归一化节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载向量归一化节点(S_设备环境& ctx, FILE* f);
void		f_node_保存向量归一化节点(C_节点基类* n, FILE* f);



class C_计算两向量点积量节点 : public C_节点基类 {
public:
	C_计算两向量点积量节点(S_设备环境& ctx);
	~C_计算两向量点积量节点();
	S_Props		m_计算类型;
	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建计算标量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载计算标量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存计算标量节点(C_节点基类* n, FILE* f);



class C_计算单向量标量节点 : public C_节点基类 {
public:
	C_计算单向量标量节点(S_设备环境& ctx);
	~C_计算单向量标量节点();
	S_Props		m_计算方式;
	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建单向量标量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载单向量标量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存单向量标量节点(C_节点基类* n, FILE* f);



class C_旋转向量节点 : public C_节点基类 {
public:
	C_旋转向量节点(S_设备环境& ctx);
	~C_旋转向量节点();
	S_Props		m_计算类型;
	bool		f_update();
	std::string DEF_节点编译函数;
	void    f_Copy(const C_节点基类* node);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建旋转向量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载旋转向量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存旋转向量节点(C_节点基类* n, FILE* f);



class C_按轴向旋转向量节点 : public C_节点基类 {
public:
	C_按轴向旋转向量节点(S_设备环境& ctx);
	~C_按轴向旋转向量节点();
	S_Props		m_计算类型;
	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建按轴向旋转向量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载按轴向旋转向量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存按轴向旋转向量节点(C_节点基类* n, FILE* f);



class C_平面到点节点 : public C_节点基类 {
public:
	C_平面到点节点(S_设备环境& ctx);
	~C_平面到点节点();
	S_Props		m_计算类型;
	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建平面向量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载平面向量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存平面向量节点(C_节点基类* n, FILE* f);



class C_平面线段相交节点 : public C_节点基类 {
public:
	C_平面线段相交节点(S_设备环境& ctx);
	~C_平面线段相交节点();
	S_Props		m_计算类型;
	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建线段平面相交节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载线段平面相交节点(S_设备环境& ctx, FILE* f);
void		f_node_保存线段平面相交节点(C_节点基类* n, FILE* f);



class C_坐标转索引节点 : public C_节点基类 {
public:
	C_坐标转索引节点(S_设备环境& ctx);
	~C_坐标转索引节点();

	S_Props		m_计算类型;

	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建坐标转索引节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载坐标转索引节点(S_设备环境& ctx, FILE* f);
void		f_node_保存坐标转索引节点(C_节点基类* n, FILE* f);




class C_索引转坐标节点 : public C_节点基类 {
public:
	C_索引转坐标节点(S_设备环境& ctx);
	~C_索引转坐标节点();

	S_Props		m_计算类型;

	bool		f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建索引转坐标节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载索引转坐标节点(S_设备环境& ctx, FILE* f);
void		f_node_保存索引转坐标节点(C_节点基类* n, FILE* f);



